home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / DSMODS / FILE.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-10  |  48.2 KB  |  2,314 lines
  1. /**********************************************************************/
  2. /* FILE: FILE.C                                  */
  3. /* DESCRIPTION: FILE I/O Routines                      */
  4. /* CREATED:                                     */
  5. /* LAST MODIFIED:   02/06/89                          */
  6. /*                                      */
  7. /*        loadfile()     - loads a file                  */
  8. /*        instring()    - Searches a string for a character   */
  9. /*        get_fs()    - Handle File Selector dialog box     */
  10. /*         save_doc()    - Save a document to disk          */
  11. /*        write_regions() - Write regions to disk              */
  12. /*        write_attrs()    - Write attributes to disk          */
  13. /*        write_prims()    - Write primitives to disk          */
  14. /*        write_articles()- Write articles to disk          */
  15. /*        write_pages()   - Write pages to disk              */
  16. /*        atbl_setup()    - Article table setup              */
  17. /*        rtble_setup()    - Region table setup              */
  18. /*        dread()        - Read characters from input buffer   */
  19. /*        dwrite()    - Write characters to file          */
  20. /*        ddump()        - Write out file buffer to disk          */
  21. /*        load_doc()    - Load document from disk          */
  22. /*        load_arts()    - Load articles from disk          */
  23. /*        getrptr()    - Get region pointer from rtable      */
  24. /*        fixup_rptrs()    - Fixup region ptrs after loading     */
  25. /*        aindex_to_ptr() - Return article index pointer        */
  26. /*        read_regions()  - Read regions from disk          */
  27. /*        read_prims()    - Read primitives from disk          */
  28. /*        read_pages()    - Read pages from disk              */
  29. /*        read_articles() - Read articles from disk          */
  30. /*        getaindex()    - Get article index              */
  31. /*        getrindex()    - Get region index               */
  32. /*        save_clipb()    - Save clipboard to disk          */
  33. /*        load_clipb()    - Load clipboard from disk          */
  34. /*        extender()    - Handle file name extenders          */
  35. /**********************************************************************/
  36.  
  37. /**************************************************************************/
  38. /* HISTORY                                  */
  39. /*                                      */
  40. /* 11/06/89  -   Added code to handle GOG.DFT file.              */
  41. /*         -   new variables : char GOGbuff[50];              */
  42. /*                 char *GOGptr;                  */
  43. /*                 char GOGindex;                  */
  44. /*         new routines:   read_GOG()                  */
  45. /*                  GOGgetstr()                  */
  46. /*                 write_GOG()                  */
  47. /*                 GOGputstr()                  */
  48. /*                 GOGputcr()                  */
  49. /*         The GOG.DFT file is read in at runtime in initsys()      */
  50. /*         The file GOG.DFT is written out in do_pwrup()          */
  51. /*         The file format is - DRESS FILE NAME              */
  52. /*                      DICTIONARY NAME              */
  53. /*                      KEYBOARD LAYOUT NAME          */
  54. /**************************************************************************/
  55.  
  56. #include "osbind.h"
  57. #include "dbase.h"
  58. #include "gemdefs.h"
  59. #include "alert.h"
  60. #include "deskset2.h"
  61. #include <obdefs.h>
  62.  
  63. /**************************************************************************/
  64. /* DEFINES                                  */
  65. /**************************************************************************/
  66. #define NOMEMORY    1
  67. #define NODATA        2
  68. #define NOFILE        3
  69.  
  70. #define DOCSIZE        5000L
  71.  
  72.  
  73. /**************************************************************************/
  74. /* EXTERNALS                                  */
  75. /**************************************************************************/
  76. extern long lcalloc();
  77. extern long lmalloc();
  78. extern long calloc();
  79. extern PAGE *get_fpage();
  80. extern PAGE *get_npage();
  81. extern REGION *get_fregion();
  82. extern REGION *get_nregion();
  83. extern ARTICLE *getf_article();
  84. extern ARTICLE *getn_article();
  85. extern unsigned char *buf_start;
  86. extern unsigned char *buf_end;
  87. extern unsigned char *free_start;
  88. extern unsigned char *current_char;
  89.  
  90. extern int force_draw_flag;
  91. extern int curr_page;
  92.  
  93. extern PAGE *pagehd;
  94. extern PAGE *clippage;
  95.  
  96. extern ARTICLE *arthd;
  97.  
  98. extern int ptsarray[];
  99.  
  100. extern int clipfull;
  101. extern unsigned char *get_lcmem();
  102. extern char *dpath1;
  103. extern char *dpath2;
  104. extern char *dpath3;
  105. extern char *dpath4;
  106. extern ARTICLE *curart;
  107.  
  108. extern int hpage_size;
  109. extern int vpage_size;
  110. extern int pagemux[];
  111. extern int pagemuy[];
  112. extern int pagetype;
  113. extern int shandle;
  114. extern int view_size;
  115. extern int pxy[];
  116. extern int cur_scale;
  117. extern GRECT pwork;
  118. extern GRECT page_area;
  119. extern int prev_handle;
  120.  
  121.  
  122. extern PAGE *tpagehd;
  123. extern PAGE *tcurpage;
  124. extern int temp_page;
  125. extern PAGE *curpage;
  126. extern PAGE *right_tmplate;
  127. extern PAGE *left_tmplate;
  128. extern int dummy;
  129. extern int tmplate_flag;
  130.  
  131. extern PNUMBER pnum;
  132.  
  133. extern ARTICLE *rtarthd;
  134. extern ARTICLE *ltarthd;
  135.  
  136. extern int pstorage[];
  137. extern char pnumtext[];
  138.  
  139. extern int active_prim;
  140. extern int scan_xres;
  141. extern int scan_yres;
  142. extern OBJECT *ad_menu;
  143.  
  144. extern char *winfo[][4];
  145. extern int unit_type;
  146.  
  147. /**************************************************************************/
  148. /* GLOBAL VARIABLES                                    */
  149. /**************************************************************************/
  150. typedef struct dta
  151.     {
  152.     char    res[21];
  153.     char    attr;
  154.     int    time;
  155.     int    date;
  156.     long    fsize;
  157.     char    str[14];
  158.     }DTA;
  159.  
  160. DTA    thedta;
  161.  
  162. long    chbuff;
  163. int    fhandle;
  164. long    bytes_in;
  165. char    *textptr;
  166. char    *endptr;
  167. char    *tmpptr;
  168. char     fbuffer[100];
  169. char    pathbuf[50];
  170. char    fname[20];
  171. char    *docbuf;
  172. char    *docend;
  173. char    *docptr;
  174.  
  175. long    *atable;
  176. long    *rtable;
  177.  
  178. unsigned int gl_rcount;
  179. long   bufpath;
  180. int    pbufindex;
  181. char *pbuff;
  182.  
  183.  
  184. long   *tatable;
  185. long   *trtable;
  186. ARTICLE *tarthd;
  187. int tcurr_page;
  188.  
  189.  
  190. int rtmplate_flag;    /* Global variables for tmplate storage */
  191. PAGE *rpagehd;        /* during save_doc() and save_tmplate() */
  192. PAGE *rcurpage;        /* If variables used anywhere else, they*/
  193. int rtemp_page;        /* are locals...            */
  194. ARTICLE *rarthd;
  195. char pfname[20];    /* string to hold title for preview window */
  196. char basefname[20];    /* string to hold title for base page       */
  197.  
  198.  
  199. char GOGbuff[50];    /* GOG default buffer            */
  200. char *GOGptr;        /* GOG ptr into buffer            */
  201. char GOGindex;        /* GOG index                */
  202.  
  203. /**********************************************************************/
  204. /* Function: loadfile()                              */
  205. /* Description: Load file 'fname' into buffer                  */
  206. /**********************************************************************/
  207. loadfile(fname)
  208. char *fname;
  209. {
  210.    long bufsize;
  211.  
  212.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  213.    if(Fsfirst(fname,0) <= -1)
  214.    {
  215.     return(0);
  216.    }
  217.    bufsize = (((thedta.fsize * 3L)> 2048L)? (thedta.fsize*3L):(2048L));
  218.    if(chbuff = lcalloc(1L,bufsize))    /* Allocate more than we need */
  219.    {
  220.      fhandle = Fopen(fname,0);
  221.      bytes_in = Fread(fhandle,thedta.fsize,chbuff);
  222.      Fclose(fhandle);
  223.      init_buffer(chbuff,chbuff+bufsize);
  224.      set_buffer(bytes_in);
  225.      return(1);
  226.    }
  227.    return(0);
  228. }
  229.  
  230.  
  231.  
  232. /************************************************************************/
  233. /*  Function: instring()                        */
  234. /*  Description: Searches a string for a particular character         */
  235. /************************************************************************/    
  236. instring(c,s)
  237. char    c;
  238. register char    *s;
  239. {
  240.     while (*s)
  241.         if (c == *s++)
  242.             return(1);
  243.     return(0);
  244. }
  245.  
  246.  
  247. /************************************************************************/
  248. /* Function: get_fs()                            */
  249. /* Description: Handle file selector                    */
  250. /************************************************************************/
  251. get_fs(buff,changed)
  252. register char *buff;
  253. int *changed;
  254. {
  255.     int button;
  256.     register int i;
  257.     register char *tbuff;
  258.         char obuf[40];
  259.         int drv;
  260.  
  261.     tbuff = pathbuf;
  262.     if(pathbuf[0] == '\0')
  263.     {
  264.         *tbuff++ = (drv =Dgetdrv()) + 'A';
  265.         *tbuff++ = ':';
  266.         *tbuff++ = '\\';
  267.         *tbuff++ = 0;
  268.         Dgetpath(obuf,drv+1);
  269.         if(strlen(obuf) == 0);
  270.         else strcat(pathbuf,&obuf[1]);
  271.     }    
  272.     strcpy(buff,pathbuf);
  273.     buff[40] = '\0';        /* filename goes here */
  274.         fname[0] = '\0';
  275.     fsel_input(buff,fname,&button);
  276.     if(!strcmp(buff,pathbuf))
  277.        *changed = 0;
  278.     else
  279.        *changed = 1;
  280.                     /* Backspace until a \ or a :    */
  281.     for (i = strlen(buff); i && !instring(buff[i],"\\:");
  282.                                            buff[i--] = '\0'); 
  283.     strcpy(pathbuf,buff);
  284.     strcat(buff,fname);
  285.     return button;
  286. }
  287.  
  288.  
  289.  
  290. /************************************************************************/
  291. /* Function: save_doc                            */
  292. /* Description:    Save a document to disk.                */
  293. /************************************************************************/
  294. save_doc()
  295. {  
  296.    int pagenum,dummy;
  297.    register unsigned int  pcount,acount,rcount;
  298.    unsigned long rtblsize;
  299.    unsigned long atblsize;
  300.    int status;   
  301.  
  302.    PAGE *pageptr;
  303.    REGION *rptr;
  304.    ARTICLE *aptr;
  305.    long magic;
  306.    
  307.    magic = 0x12445334L;            /* 12DS34 */
  308.    status = FALSE;
  309.  
  310.    strcpy(pathbuf,dpath4);
  311.    strcat(pathbuf,"*.DS2");
  312.    if(!get_fs(fbuffer,&dummy))
  313.     return;
  314.  
  315.    push_sdoc();
  316.    extender(fbuffer,".DS2");   
  317.  
  318.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  319.    if(Fsfirst(fbuffer,0) == 0)            /* File Already Exists  */
  320.    {
  321.     if(alert_cntre(ALERT37) == 2)        /* Cancel Button pressed*/
  322.     {
  323.       pop_sdoc();
  324.       return;
  325.     }
  326.    }
  327.    
  328.  
  329.    
  330.    pageptr = get_fpage(&pagenum);
  331.    if(!pageptr)
  332.    {
  333.     pop_sdoc();
  334.     return;
  335.    }
  336.  
  337.  
  338.    
  339.    docbuf = (char *)lmalloc(DOCSIZE);
  340.    if(!docbuf)
  341.    {
  342.     alert_cntre(ALERT12);    
  343.     pop_sdoc();
  344.     return;
  345.    }
  346.    docptr = docbuf;
  347.    docend = docbuf + DOCSIZE;   /* Points to 1 past max address */
  348.  
  349.    acount = 0;
  350.    rcount = 0;            /* Initialize region count      */
  351.    pcount = 0;            /* Initialize page count    */
  352.  
  353.    while(pageptr)
  354.    {
  355.        pcount++;
  356.        rptr = get_fregion(pagenum,&dummy,&dummy,&dummy,&dummy,&dummy);
  357.        while(rptr)
  358.        {
  359.            rcount++;
  360.            rptr = get_nregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  361.        }
  362.        pageptr = get_npage(&pagenum);
  363.    }
  364.    rtblsize = 4L * ((long)rcount + 1L);
  365.  
  366.    rtable = (long *)lmalloc(rtblsize);
  367.    if(!rtable)
  368.    {
  369.     alert_cntre(ALERT12);
  370.     free(docbuf);
  371.     pop_sdoc();
  372.     return;
  373.    }
  374.    aptr = getf_article();
  375.    while(aptr)
  376.    {
  377.     acount++;
  378.     aptr = getn_article();
  379.    }
  380.    atblsize = 4L * ((long)acount + 1L);
  381.    atable = (long *)lmalloc(atblsize);
  382.    if(!atable)
  383.    {
  384.     free(rtable);
  385.     free(docbuf);
  386.     alert_cntre(ALERT12);
  387.     pop_sdoc();
  388.     return;
  389.    }
  390.   
  391.    rtbl_setup();            /* Set up region table  */
  392.    atbl_setup();            /* Set up article table */
  393.  
  394.    if((fhandle = Fcreate(fbuffer,0)) <= 0)
  395.    {
  396.     alert_cntre(ALERT19);
  397.     pop_sdoc();
  398.      return;
  399.    }
  400.  
  401.    dwrite(&magic,4);            /* Magic value        */
  402.    if(write_pages(pcount)    &&     /* If each is successful then */
  403.       write_articles(acount) &&     /* continue to write the next */
  404.       write_regions(rcount)  &&        /* else short circuit the     */
  405.       write_tags()          &&        /* while statement and stop   */
  406.       write_setp()           &&        /* writing              */
  407.       write_ptype()         &&
  408.       write_pnums()         &&        /* write page number info...  */
  409.       ddump())                /* Dump the buffer    */
  410.  
  411.     ;    /* Everything was written OK */
  412.         /* Let aes handle error messages */
  413.  
  414.    free(atable);
  415.    free(rtable);
  416.    free(docbuf);
  417.  
  418.  
  419.    if(Fclose(fhandle))
  420.     alert_cntre(ALERT18);        /* Close the file     */
  421.  
  422.    pop_sdoc();                /* restore variables  */
  423.    strcpy(pfname," ");
  424.    strcat(pfname,fname);
  425.    extender(pfname,".DS2");
  426.    strcat(pfname," ");
  427.    wind_set(prev_handle,WF_NAME,pfname,0,0);
  428. }
  429.  
  430.  
  431.  
  432. /************************************************************************/
  433. /* Function: write_regions()                        */
  434. /* Description: write regions to disk                    */
  435. /************************************************************************/
  436. write_regions(rcount)
  437. unsigned int rcount;
  438. {
  439.    register int i;
  440.    long rptr;
  441.    
  442.    if(!dwrite(&rcount,2))    /* Write number of regions    */
  443.             return(0);
  444.    for(i = 0;i < rcount;i++)
  445.    {
  446.     rptr = rtable[i];
  447.     if(!write_attrs(rptr))
  448.             return(0);
  449.     if(!write_prims(rptr))
  450.                    return(0);
  451.    }
  452.    return(1);                /* ok */
  453. }
  454.  
  455.  
  456.  
  457.  
  458. /************************************************************************/
  459. /* Function: write_attrs()                        */
  460. /* Description: write attributes to disk                */
  461. /************************************************************************/
  462. write_attrs(rptr)
  463. register REGION *rptr;
  464. {
  465.    unsigned int temp;
  466.  
  467.  
  468.    temp = ((!rptr->artptr) ? (0xffff) : (getaindex(rptr->artptr)));
  469.  
  470.    if(!dwrite(&temp,2))
  471.         return(0);
  472.    temp = ((!rptr->plink) ? (0xffff) : (getrindex(rptr->plink)));
  473.  
  474.    if(!dwrite(&temp,2))
  475.         return(0);
  476.  
  477.    temp = ((!rptr->alink) ? (0xffff) : (getrindex(rptr->alink)));
  478.  
  479.    if(!dwrite(&temp,2))
  480.         return(0);
  481.    if(!dwrite(&rptr->x1,10))              /* write x1,y1,x2,y2,p    */
  482.         return(0);
  483.    if(!dwrite(&rptr->reserved,4))          /* 2 reserved words         */
  484.         return(0);
  485.    if(!dwrite(&rptr->text,sizeof(struct txtattr)))/* Write text attributes  */
  486.         return(0);
  487.    if(!dwrite(&rptr->grattr[0],2*11))            /* Graphic attributes     */
  488.         return(0);
  489.    if(!dwrite(&rptr->type,2))                /* Write type            */
  490.         return(0);
  491.    return(1);                      /* no error */
  492. }
  493.  
  494.  
  495.  
  496.  
  497. /************************************************************************/
  498. /* Function: write_prims()                        */
  499. /* Description: write primitives to disk                */
  500. /************************************************************************/
  501. write_prims(rptr)
  502. REGION *rptr;
  503. {
  504.    int pcount;
  505.    int count,wrmode,op;
  506.  
  507.    pcount = 0;
  508.  
  509.    op = get_fprimitive(rptr,&count,&wrmode);
  510.    while(op != 0xffff)
  511.    {
  512.     pcount++;
  513.     op = get_nprimitive(&count,&wrmode);
  514.    }
  515.    if(!dwrite(&pcount,2))
  516.         return(0);
  517.  
  518.    op = get_fprimitive(rptr,&count,&wrmode);
  519.    while(op != 0xffff)
  520.    {
  521.     if(!dwrite(&op,2))            /* Write opcode         */
  522.            return(0);
  523.     if(!dwrite(&wrmode,2))            /* Write writing mode   */
  524.            return(0);
  525.     if(!dwrite(&count,2))            /* Write ptsarray count */
  526.            return(0);
  527.     if(!dwrite(&ptsarray[0],4*count))    /* Write points     */
  528.            return(0);
  529.     op = get_nprimitive(&count,&wrmode);
  530.    }
  531.    return(1);
  532. }
  533.        
  534. save_article(artptr)
  535. ARTICLE *artptr;
  536. {
  537.       if(artptr->dirty)
  538.       {
  539.          open_article(artptr);
  540.          strcpy(fbuffer,dpath1);
  541.          strcat(fbuffer,&artptr->filename[0]);
  542.          get_abuffvars(artptr);
  543.          write_file(fbuffer);
  544.          artptr->dirty = 0; 
  545.       }
  546. }
  547.  
  548. /************************************************************************/
  549. /* Function: write_articles()                        */
  550. /* Description: write articles to disk                    */
  551. /************************************************************************/
  552. write_articles(acount)
  553. unsigned int acount;
  554. {
  555.    register int i;
  556.    ARTICLE *aptr;
  557.    REGION  *rptr;
  558.    int temp;
  559.  
  560.    if(!dwrite(&acount,2))        /* Write number of articles    */
  561.         return(0);
  562.    for(i = 0;i < acount; i++)
  563.    {
  564.     aptr = (ARTICLE *)atable[i];
  565.     rptr = aptr->regptr;
  566.  
  567.     temp = ((rptr) ? (getrindex(rptr)) : (0xffff));
  568.         if(!dwrite(&temp,2))        /* Write index of first region  */
  569.             return(0);
  570.     if(!dwrite(&aptr->filename[0],40))    /* Write filename    */
  571.             return(0);
  572.     
  573.     save_article(aptr);
  574.    }
  575.    return(1);
  576. }
  577.  
  578.  
  579.  
  580.        
  581. /************************************************************************/
  582. /* Function: write_pages()                        */
  583. /* Description: Write pages to disk                    */
  584. /************************************************************************/
  585. write_pages(pcount)
  586. unsigned int pcount;
  587. {
  588.    PAGE *pageptr;
  589.    REGION *rptr;
  590.    int pagenum,dummy;
  591.    int temp;
  592.  
  593.    if(!dwrite(&pcount,2))        /* Write number of pages      */
  594.         return(0);
  595.    pageptr = get_fpage(&pagenum);
  596.    rptr = get_fregion(pagenum,&dummy,&dummy,&dummy,&dummy,&dummy);
  597.    while(pageptr)
  598.    {
  599.     if(!dwrite(&pagenum,2))        /* Write page number         */
  600.             return(0);
  601.                     /* Write index of first region       */
  602.                     /* else -1 = no region for this page */
  603.     temp = ((rptr) ? (getrindex(rptr)) : (0xffff));
  604.         if(!dwrite(&temp,2))
  605.         return(0);
  606.     pageptr = get_npage(&pagenum);
  607.         rptr = get_fregion(pagenum,&dummy,&dummy,&dummy,&dummy,&dummy);
  608.    }
  609.    return(1);
  610. }
  611.  
  612.  
  613.  
  614.  
  615.  
  616. /************************************************************************/
  617. /* Function: atbl_setup()                        */
  618. /* Description: Article Table setup                    */
  619. /************************************************************************/
  620. atbl_setup()
  621. {
  622.    register int i;
  623.    ARTICLE *aptr;
  624.  
  625.    i = 0;
  626.  
  627.    aptr = getf_article();
  628.    while(aptr)
  629.    {
  630.     atable[i++] = (long)aptr;
  631.     aptr = getn_article();
  632.    }
  633.    atable[i] = 0L;
  634. }
  635.  
  636.  
  637.  
  638.     
  639. /************************************************************************/
  640. /* Function: rtbl_setup()                        */
  641. /* Description: region table setup                    */
  642. /************************************************************************/
  643. rtbl_setup()
  644. {
  645.    PAGE *pageptr;
  646.    REGION *rptr;
  647.    register int i;
  648.    int pagenum;
  649.    int dummy;
  650.  
  651.    i = 0;
  652.    pageptr = get_fpage(&pagenum);
  653.    while(pageptr)
  654.    {
  655.     rptr = get_fregion(pagenum,&dummy,&dummy,&dummy,&dummy,&dummy);
  656.     while(rptr)
  657.     {
  658.         rtable[i++] = (long)rptr;
  659.         rptr = get_nregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  660.     }
  661.     pageptr = get_npage(&pagenum);
  662.    }
  663.    rtable[i] = 0L;
  664. }
  665.  
  666.  
  667.  
  668.  
  669. /************************************************************************/
  670. /* Function: dread()                            */
  671. /* Description: read characters from input buffer            */
  672. /************************************************************************/
  673. dread(cptr,count)
  674. register char *cptr;
  675. register int count;
  676. {
  677.    while(count--)
  678.    {
  679.     *cptr++ = *docptr++;
  680.    }
  681.    if(count != -1)
  682.     return(0);
  683.    else
  684.         return(1);
  685. }
  686.  
  687.  
  688.  
  689.  
  690. /************************************************************************/
  691. /* Function: dwrite()                            */
  692. /* Description: Write characters to file                */
  693. /************************************************************************/
  694. dwrite(cptr,count)
  695. register char *cptr;
  696. register int count;
  697. {
  698.    while(count--)
  699.    {
  700.     if(docptr == docend)
  701.     {
  702.        if(!ddump())
  703.            return(0);            /* error */
  704.     }
  705.     *docptr++ = *cptr++;
  706.    }
  707.    return(1);        /*ok */
  708. }
  709.  
  710.  
  711.  
  712.  
  713.  
  714. /************************************************************************/
  715. /* Function: ddump()                            */
  716. /* Description: Write out file buffer to disk                */
  717. /************************************************************************/
  718. ddump()
  719. {
  720.    long count;
  721.    long num;
  722.  
  723.    count = (long)docptr - (long)docbuf;
  724.    if((num = Fwrite(fhandle,count,docbuf)) >= 0)
  725.    {
  726.      docptr = docbuf;
  727.      return(1);                    /* ok */
  728.    }
  729.    return(0);                    /* error */
  730. }
  731.  
  732.  
  733.  
  734.  
  735.  
  736. /************************************************************************/
  737. /* Function: load_doc()                            */
  738. /* Description:                                */
  739. /*     Load a document from disk and set up region, article, and page  */
  740. /*    structures.                            */
  741. /************************************************************************/
  742. load_doc(docname)
  743. char *docname;
  744. {
  745.    long bufsize;
  746.    int dummy;
  747.    long magic;
  748.    int i;
  749.  
  750.    if(docname)
  751.    {
  752.       strcat(fbuffer,docname);
  753.    }
  754.    else
  755.    {
  756.       strcpy(pathbuf,dpath4);
  757.       strcat(pathbuf,"*.DS2");
  758.       if(!get_fs(fbuffer,&dummy))
  759.       {
  760.       return;
  761.       }
  762.       extender(fbuffer,".DS2");
  763.    }
  764.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  765.    if(Fsfirst(fbuffer,0) <= -1)
  766.    {
  767.       alert_cntre(ALERT8);
  768.       return;
  769.    }
  770.    bufsize = thedta.fsize;
  771.    if(!bufsize)
  772.    {
  773.       alert_cntre(ALERT39);
  774.       return;
  775.    }
  776.  
  777.    docbuf = (char *)lcalloc(1L,bufsize);
  778.    if(!docbuf)
  779.    {
  780.     alert_cntre(ALERT12);
  781.     return;
  782.    }
  783.  
  784.    docptr = docbuf;
  785.    if((fhandle = Fopen(fbuffer,0)) <= 0)
  786.    {
  787.     free(docbuf);
  788.     alert_cntre(ALERT16);
  789.     return;
  790.    }
  791.    bytes_in = Fread(fhandle,thedta.fsize,docbuf);
  792.    if(bytes_in < thedta.fsize)
  793.    {
  794.     free(docbuf);
  795.     alert_cntre(ALERT17);
  796.         Fclose(fhandle);
  797.     return;
  798.    }
  799.    Fclose(fhandle);
  800.  
  801.    erase_all(1);                /* Start fresh         */
  802.    dread(&magic,4);
  803.    if(magic != 0x12445334L)        /* Magic value 12DS34 */
  804.    {
  805.     free(docbuf);
  806.     alert_cntre(ALERT29);
  807.     return;
  808.    }   
  809.    if(read_pages()   && 
  810.    read_articles()   &&
  811.    read_regions())
  812.     ;        /* Everything is OK */
  813.    else
  814.    {
  815.         alert_cntre(ALERT12);        /* Not enough memory    */
  816.     dbase_cleanup();
  817.     free(rtable);
  818.     free(docbuf);
  819.         return;
  820.    }
  821.    
  822.    free(rtable);
  823.    fixup_rptrs();
  824.    load_arts();
  825.    clear_tags();
  826.    read_tags();
  827.    read_setp();
  828.    sysfiles();                /* setup setp files */
  829.    read_ptype();
  830.    read_pnums();            /* read page number info*/
  831.  
  832.    curpage = pagehd;
  833.    curr_page = pagehd->pagenum;
  834.  
  835.    free(docbuf);
  836.  
  837.    strcpy(pfname," ");
  838.    if(docname)
  839.     strcat(pfname,docname);
  840.    else
  841.         strcat(pfname,fname);
  842.    strcat(pfname," ");
  843.    wind_set(prev_handle,WF_NAME,pfname,0,0);
  844.    do_pagenum(curr_page,(curr_page%2)?1:0);
  845.  
  846.    hpage_size = pagemux[pagetype - PA4];
  847.    vpage_size = pagemuy[pagetype - PA4];
  848.    page_area.g_x = page_area.g_y = 0L;
  849.    mutomem(hpage_size,vpage_size,&scan_xres,&scan_yres);
  850.    if(pagetype == PLEGAL + 4)    /* Legal Landscape   ? */
  851.    {                /* view_size == P200 or PADJCNT? */
  852.        if((view_size == P200) || (view_size == PADJCNT))
  853.        {
  854.                                   view_size = PACTUAL;
  855.           for(i=PSIZE;i<= PADJCNT;i++)
  856.               menu_icheck(ad_menu,i,FALSE);
  857.           menu_icheck(ad_menu,view_size,TRUE);
  858.           wind_set(prev_handle,WF_INFO,winfo[view_size - PSIZE][unit_type]);
  859.        }
  860.        menu_ienable(ad_menu,P200,FALSE);
  861.        menu_ienable(ad_menu,PADJCNT,FALSE);
  862.    }
  863.    else
  864.    {
  865.        menu_ienable(ad_menu,P200,TRUE);
  866.        menu_ienable(ad_menu,PADJCNT,TRUE);
  867.    }
  868.    gsx_moff();
  869.    vsf_interior(shandle,0);
  870.  
  871.    if((view_size == PSIZE) ||
  872.       (view_size == PADJCNT))
  873.           pdraw_fit(view_size);
  874.    else
  875.       pdraw_scale();
  876.  
  877.    vr_recfl(shandle,pxy);
  878.    gsx_mon();
  879.    zoom_setup();
  880.    cur_scale = get_scale_num(view_size);
  881.    get_work(prev_handle);
  882.    update_preview_blit();
  883.    clear_window(prev_handle,2,1);
  884.    set_clip(TRUE,&pwork);
  885.  
  886.    graf_mouse(2,&dummy);
  887.  
  888.    init_rulers();
  889.    recalc_txtptrs();
  890.    force_preview();
  891.    slider_chk();
  892.    graf_mouse(ARROW,&dummy);
  893. }
  894.  
  895.  
  896. /************************************************************************/
  897. /*    Clean up data structures of pages,articles, and regions        */
  898. /************************************************************************/
  899. dbase_cleanup()
  900. {
  901. register PAGE *tpage;
  902. PAGE *npage;
  903. register ARTICLE *tart;
  904. ARTICLE *nart;
  905.  
  906.    tpage = npage = pagehd;        /* Clean up pages     */
  907.    while(tpage)
  908.    {
  909.     npage = tpage->nextpage;
  910.     free(tpage);
  911.      tpage = npage;
  912.    }
  913.    tart = nart = arthd;            /* Clean up articles    */
  914.    while(tart)
  915.    {
  916.     nart = tart->nextart;
  917.     free(tart);
  918.      tart = nart;
  919.    }
  920.    clean_regions();
  921.    pagehd = (PAGE *)0L;
  922.    arthd  = (ARTICLE *)0L;
  923. }
  924.  
  925.  
  926. /************************************************************************/
  927. /*    Clean up regions in rtable along with their prims and ptsblks   */
  928. /************************************************************************/
  929. clean_regions()
  930. {
  931. REGION *rptr;
  932. PRIMITIVE *nprim;
  933. register PRIMITIVE *tprim;
  934. PTSBLK *nblk;
  935. PTSBLK *tblk;
  936. register int i;
  937.  
  938.    for(i = 0; i < gl_rcount;i++)        /* Clean up regions       */
  939.    {
  940.     rptr = (REGION *)rtable[i];
  941.        tprim = nprim = rptr->primlist;        /* Clean up primitives    */
  942.     while(tprim)
  943.         {
  944.        nprim = tprim->nextprim;
  945.           tblk = nblk = tprim->blkptr;      /* Clean up blocks      */
  946.        while(tblk)
  947.            {
  948.           nblk = tblk->nextblk;
  949.           free(tblk);
  950.            tblk = nblk;
  951.            }    
  952.        free(tprim);
  953.         tprim = nprim;
  954.         }    
  955.         free(rptr);
  956.     }
  957. }
  958.  
  959. /************************************************************************/
  960. /* Function: load_arts()                        */
  961. /* Description: load articles from disk                    */
  962. /************************************************************************/
  963. load_arts()
  964. {
  965. register ARTICLE *aptr;
  966. ARTICLE *naptr;
  967. ARTICLE *pptr;
  968.  
  969. register REGION  *rptr;
  970. REGION  *rnext;
  971.  
  972.    aptr = arthd;
  973.    while(aptr)
  974.    {
  975.     strcpy(fbuffer,dpath1);
  976.     strcat(fbuffer,&aptr->filename[0]);
  977.     if(!loadfile(fbuffer))
  978.         {
  979.        rptr = aptr->regptr;
  980.  
  981.        while(rptr)
  982.            {
  983.         rptr->artptr = 0L;        /* clear ptr to article    */
  984.         rnext = rptr->alink;           
  985.         rptr->alink = 0L;        /* clear ptr to next region*/
  986.                 rptr = rnext;            /* go on to next article   */
  987.            }
  988.            aptr->filename[0] = '\0';        /* clear filename of articl*/
  989.            aptr->regptr = 0L;                /* zero it out */
  990.        aptr->dirty  = 0;
  991.        
  992.         }
  993.         else
  994.         {
  995.         aptr->buf_start = buf_start;
  996.         aptr->buf_end = buf_end;
  997.         aptr->free_start = free_start;
  998.         aptr->current_char = current_char;
  999.         aptr->dirty  = 0;
  1000.         }
  1001.     aptr = aptr->nextart;
  1002.    }
  1003.  
  1004.    pptr = aptr = arthd;
  1005.    while(aptr)
  1006.    {
  1007.  
  1008.       if(aptr->regptr == 0L)
  1009.       {
  1010.  
  1011.       if(aptr == arthd)
  1012.           {
  1013.               naptr = aptr->nextart;
  1014.           arthd = pptr = naptr;
  1015.           free(aptr);
  1016.            aptr = naptr;
  1017.           }
  1018.           else
  1019.           {
  1020.         naptr = aptr->nextart;
  1021.         pptr->nextart = naptr;
  1022.         free(aptr);
  1023.         aptr = naptr;
  1024.           }
  1025.  
  1026.       }
  1027.       else
  1028.       {
  1029.  
  1030.      pptr = aptr;
  1031.          aptr = aptr->nextart;
  1032.       }
  1033.    }
  1034.  
  1035.    return(1);
  1036. }
  1037.  
  1038.  
  1039.  
  1040.  
  1041. /**********************************************************************/
  1042. /* Function: getrptr()                              */
  1043. /* Description: get region pointer from region table              */
  1044. /**********************************************************************/
  1045. REGION *getrptr(index)
  1046. int index;
  1047. {
  1048.    if(index == 0xffff)
  1049.     return (REGION *)0L;
  1050.    else
  1051.         return (REGION *)rtable[index];   
  1052. }
  1053.  
  1054.  
  1055.  
  1056.  
  1057. /**********************************************************************/
  1058. /* Function: fixup_rptrs()                          */
  1059. /* Description: Fixup region pointers after loading...              */
  1060. /**********************************************************************/
  1061. fixup_rptrs()
  1062. {
  1063.    register REGION *rptr;
  1064.    register ARTICLE *aptr;
  1065.    register PAGE *pptr;
  1066.    register int i;
  1067.  
  1068.    for(i = 0;i < gl_rcount;i++)
  1069.    {
  1070.     rptr = (REGION *)rtable[i];
  1071.     rptr->alink = getrptr((int)rptr->alink);
  1072.     rptr->plink = getrptr((int)rptr->plink);
  1073.    }
  1074.    pptr = pagehd;
  1075.    while(pptr)
  1076.    {
  1077.     pptr->regptr = getrptr((int)pptr->regptr);
  1078.       pptr = pptr->nextpage;
  1079.    }
  1080.    aptr = arthd;
  1081.    while(aptr)
  1082.    {
  1083.     aptr->regptr = getrptr((int)aptr->regptr);
  1084.     aptr = aptr->nextart;
  1085.    }
  1086. }
  1087.  
  1088.  
  1089.  
  1090. /**********************************************************************/
  1091. /* Function: aindex_to_ptr()                          */
  1092. /* Description: Return article index pointer                  */
  1093. /**********************************************************************/
  1094. ARTICLE *aindex_to_ptr(index)
  1095. unsigned int index;
  1096. {
  1097.    register int i;
  1098.    register ARTICLE *aptr;
  1099.  
  1100.    if(index == 0xffff)
  1101.     return (ARTICLE *)0L;
  1102.    aptr = arthd;
  1103.    for(i = 0; i < index;i++)
  1104.     aptr = aptr->nextart;
  1105.    return aptr;
  1106. }
  1107.  
  1108.  
  1109.  
  1110.  
  1111. /**********************************************************************/
  1112. /* Function: read_regions()                          */
  1113. /* Description: Read regions from disk                      */
  1114. /**********************************************************************/
  1115. read_regions()
  1116. {
  1117.    long rtblsize;
  1118.    register REGION  *rptr;
  1119.    unsigned int rindex;
  1120.    unsigned int aindex;
  1121.    long temp;
  1122.    register int i;
  1123.  
  1124.    dread(&gl_rcount,2);
  1125.    rtblsize = 4L * (long)gl_rcount;
  1126.    if(!(rtable = (long *)lmalloc(rtblsize)))
  1127.                        return(0);
  1128.    for(i = 0;i < gl_rcount;i++)
  1129.    {
  1130.       if(!(rptr = (REGION *)calloc(1,sizeof(REGION))))
  1131.                         return(0);
  1132.       rtable[i] = (long)rptr;
  1133.       dread(&aindex,2);
  1134.       rptr->artptr = aindex_to_ptr(aindex);
  1135.       dread(&rindex,2);
  1136.       temp = ((long)rindex & 0xffff);
  1137.       rptr->plink = (REGION *)temp;
  1138.       dread(&rindex,2);
  1139.       temp = ((long)rindex & 0xffff);
  1140.       rptr->alink = (REGION *)temp;
  1141.       dread(&rptr->x1,10);            /* Read x1,y1,x2,y2,p     */
  1142.       dread(&rptr->reserved,4);            /* 2 reserved words      */
  1143.       dread(&rptr->text,sizeof(struct txtattr));/* Read text attributes   */
  1144.       dread(&rptr->grattr[0],2*11);        /* Graphic attributes     */
  1145.       dread(&rptr->type,2);            /* Read type          */    
  1146.       if(!read_prims(rptr))            /* Read in primitives     */
  1147.               return(0);
  1148.    }
  1149.    return(1);
  1150. }
  1151.  
  1152.  
  1153.  
  1154.  
  1155. /**********************************************************************/
  1156. /* Function: read_prims()                          */
  1157. /* Description: read primitives from disk                  */
  1158. /**********************************************************************/
  1159. read_prims(rptr)
  1160. REGION *rptr;
  1161. {
  1162.    register int i,j,k;
  1163.    int pcount;
  1164.    PRIMITIVE *prevprim;
  1165.    PRIMITIVE  *newprim;
  1166.    register PTSBLK *curblk;
  1167.    register int count;
  1168.  
  1169.    dread(&pcount,2);
  1170.    if(!(prevprim = (PRIMITIVE *)calloc(1,sizeof(PRIMITIVE))))
  1171.                             return(0);
  1172.    rptr->primlist = prevprim;
  1173.  
  1174.    for(i = 0;i < pcount;i++)
  1175.    {
  1176.       dread(&prevprim->op,6);            /* Read op,wrmode,#pts */
  1177.       if(!(curblk = (PTSBLK *)calloc(1,sizeof(PTSBLK))))
  1178.                                return(0);
  1179.       curblk->nextblk = 0L;
  1180.       prevprim->blkptr = curblk;
  1181.       count = prevprim->numpts;
  1182.       count *= 2;            /* count = # vertices */
  1183.       dread(ptsarray,count*2);        /* times 2 for # of chars */
  1184.       j = k = 0;
  1185.       while(count--)
  1186.       {
  1187.     curblk->points[j++] = ptsarray[k++];
  1188.       if(j >= MAXBLK)
  1189.      {
  1190.        if(!(curblk->nextblk = (PTSBLK *)calloc(1,sizeof(PTSBLK))))
  1191.                                         return(0);
  1192.        curblk = curblk->nextblk;
  1193.        curblk->nextblk = 0L;
  1194.        j = 0;
  1195.     }
  1196.       }
  1197.       if(i == pcount - 1)
  1198.     newprim = 0L;
  1199.       else
  1200.       {
  1201.         if(!(newprim = (PRIMITIVE *)calloc(1,sizeof(PRIMITIVE))))
  1202.                             return(0);
  1203.       }
  1204.       prevprim->nextprim = newprim;
  1205.       prevprim = newprim;
  1206.    }
  1207.    return(1);
  1208. }
  1209.  
  1210.  
  1211.  
  1212.  
  1213. /**********************************************************************/
  1214. /* Function: read_pages()                          */
  1215. /* Description: read pages from disk                      */
  1216. /**********************************************************************/
  1217. read_pages()
  1218. {
  1219.    int pcount;
  1220.    PAGE *newpage;
  1221.    register PAGE *prevpage;
  1222.    unsigned int rindex;
  1223.    long temp;
  1224.    register int i;
  1225.    int pagenum;
  1226.  
  1227.    dread(&pcount,2);
  1228.    if(!(prevpage = (PAGE *)calloc(1,sizeof(PAGE))))
  1229.                         return(0);
  1230.    pagehd = prevpage;
  1231.  
  1232.    for(i = 0;i < pcount;i++)
  1233.    {
  1234.       dread(&pagenum,2);
  1235.       prevpage->pagenum = pagenum;
  1236.       dread(&rindex,2);
  1237.       temp = ((long)rindex & 0xffff);
  1238.       prevpage->regptr = (REGION *)temp;
  1239.       if(i == pcount - 1)
  1240.     newpage = 0L;
  1241.       else
  1242.       {
  1243.         if(!(newpage = (PAGE *)calloc(1,sizeof(PAGE))))
  1244.                         return(0);
  1245.       }
  1246.       prevpage->nextpage = newpage;
  1247.       prevpage = newpage;
  1248.    }
  1249.    return(1);
  1250. }
  1251.  
  1252.  
  1253.  
  1254.  
  1255. /**********************************************************************/
  1256. /* Function: read_articles()                          */
  1257. /* Description: read articles from disk                      */
  1258. /**********************************************************************/
  1259. read_articles()
  1260. {
  1261.    int acount;
  1262.    ARTICLE *newart;
  1263.    register ARTICLE *prevart;
  1264.    unsigned int rindex;
  1265.    long temp;
  1266.    register int i;
  1267.  
  1268.    dread(&acount,2);
  1269.    if(acount == 0)
  1270.     return(1);
  1271.    if(!(prevart = (ARTICLE *)calloc(1,sizeof(ARTICLE))))
  1272.                         return(0);
  1273.    arthd = prevart;
  1274.  
  1275.    for(i = 0;i < acount;i++)
  1276.    {
  1277.       dread(&rindex,2);
  1278.       temp = ((long)rindex & 0xffff);
  1279.       prevart->regptr = (REGION *)temp;        /* Fill in the first region */
  1280.       dread(&prevart->filename[0],40);        /* Fill in the file name */
  1281.       if(i == acount - 1)
  1282.     newart = 0L;
  1283.       else
  1284.       {
  1285.         if(!(newart = (ARTICLE *)calloc(1,sizeof(ARTICLE))))
  1286.                             return(0);
  1287.       }
  1288.       prevart->nextart = newart;
  1289.       prevart = newart;
  1290.    }
  1291.    return(1);
  1292. }
  1293.  
  1294.  
  1295.  
  1296.  
  1297. /**********************************************************************/
  1298. /* Function: getaindex()                          */
  1299. /* Description: get article index                      */
  1300. /**********************************************************************/
  1301. getaindex(aptr)
  1302. ARTICLE *aptr;
  1303. {
  1304.    register int i;
  1305.  
  1306.    i = 0;
  1307.    while(atable[i])
  1308.    {
  1309.     if(atable[i] == (long)aptr)
  1310.     {
  1311.        return i;
  1312.     }
  1313.     i++;
  1314.    }
  1315. }
  1316.  
  1317.  
  1318.  
  1319.  
  1320. /**********************************************************************/
  1321. /* Function: getrindex()                          */
  1322. /* Description: get region index()                      */
  1323. /**********************************************************************/
  1324. getrindex(rptr)
  1325. REGION *rptr;
  1326. {
  1327.    register int i;
  1328.    i = 0;
  1329.    while(rtable[i])
  1330.    {
  1331.     if(rtable[i] == (long)rptr)
  1332.     {
  1333.        return i;
  1334.     }
  1335.         i++;
  1336.    }
  1337. }
  1338.  
  1339.  
  1340.  
  1341.  
  1342.  
  1343. /************************************************************************/
  1344. /* Function: save_clipb()                        */
  1345. /* Description:    Save clipboard to disk                    */
  1346. /************************************************************************/
  1347. save_clipb()
  1348. {
  1349.    unsigned long rtblsize;
  1350.    register unsigned int rcount;      
  1351.    register REGION *rptr;
  1352.    int i;
  1353.    int status;
  1354.  
  1355.    status = FALSE;
  1356.    if(!clipfull)    /* does this check the same thing as...*/
  1357.     return;
  1358.  
  1359.    if(!clippage->regptr)   /* this? Oh, well...just in case... */
  1360.         return;
  1361.  
  1362.    active_prim = FALSE;
  1363.    strcpy(pathbuf,dpath2);
  1364.    strcat(pathbuf,"*.CLP");
  1365.    if(!get_fs(fbuffer,&i))
  1366.    {
  1367.     return;
  1368.    }
  1369.    extender(fbuffer,".CLP");   
  1370.  
  1371.  
  1372.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  1373.    if(Fsfirst(fbuffer,0) == 0)            /* File Already Exists  */
  1374.    {
  1375.     if(alert_cntre(ALERT37) == 2)        /* Cancel Button pressed*/
  1376.             return;
  1377.    }
  1378.  
  1379.  
  1380.    if((fhandle = Fcreate(fbuffer,0)) <=0)
  1381.    {
  1382.     alert_cntre(ALERT19);
  1383.     return;
  1384.    }
  1385.    docbuf = (char *)lmalloc(DOCSIZE);
  1386.    if(!docbuf)
  1387.    {
  1388.     alert_cntre(ALERT12);
  1389.     Fclose(fhandle);
  1390.     return;
  1391.    }
  1392.    docptr = docbuf;
  1393.    docend = docbuf + DOCSIZE - 1;
  1394.    rcount = 0;            /* Initialize region count      */
  1395.  
  1396.    rptr = clippage->regptr;
  1397.    while(rptr)
  1398.    {
  1399.        rcount++;
  1400.        rptr = rptr->plink;
  1401.    }  
  1402.  
  1403.    rtblsize = 4L * ((long)rcount + 1L);
  1404.    rtable = (long *)lmalloc(rtblsize);
  1405.    if(!rtable)
  1406.    {
  1407.     free(docbuf);
  1408.     alert_cntre(ALERT12);
  1409.     Fclose(fhandle);
  1410.     return;
  1411.    }
  1412.    rptr = clippage->regptr;
  1413.    i = 0;
  1414.    while(rptr)
  1415.    {
  1416.          rtable[i++] = (long)rptr;
  1417.          rptr = rptr->plink;
  1418.    }  
  1419.    if(write_regions(rcount))
  1420.    {
  1421.          if(!ddump())    /* Dump the buffer        */
  1422.          alert_cntre(ALERT20);
  1423.    }
  1424.    else
  1425.      alert_cntre(ALERT20);            
  1426.    free(rtable);
  1427.    free(docbuf);
  1428.    Fclose(fhandle);            /* Close the file        */
  1429. }
  1430.  
  1431.  
  1432.  
  1433. /************************************************************************/
  1434. /* Function: load_clipb()                        */
  1435. /* Description:    Load clipboard                        */
  1436. /************************************************************************/
  1437. load_clipb()
  1438. {
  1439.    long bufsize;
  1440.    int i;
  1441.    REGION *rptr;
  1442.    int status;
  1443.  
  1444.    status = FALSE;
  1445.  
  1446.    strcpy(pathbuf,dpath2);
  1447.    strcat(pathbuf,"*.CLP");
  1448.    if(!get_fs(fbuffer,&i))
  1449.    {
  1450.     return NOFILE;
  1451.    }
  1452.    extender(fbuffer,".CLP");
  1453.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  1454.    if(Fsfirst(fbuffer,0) <= -1)
  1455.    {
  1456.     alert_cntre(ALERT8);
  1457.     return NOFILE;
  1458.    }
  1459.  
  1460.    if(!thedta.fsize)
  1461.    {
  1462.     alert_cntre(ALERT39);
  1463.         return(1);
  1464.    }
  1465.    delete_clip();
  1466.    clippage = (PAGE *)get_lcmem((long)sizeof(PAGE));
  1467.    if(!clippage)
  1468.    {
  1469.     alert_cntre(ALERT12);
  1470.     return(1);
  1471.    }
  1472.    bufsize = thedta.fsize;
  1473.    docbuf = (char *)lcalloc(1L,bufsize);
  1474.    if(!docbuf)
  1475.    {
  1476.     free(clippage);
  1477.     alert_cntre(ALERT12);
  1478.     return(1);
  1479.    }
  1480.    docptr = docbuf;
  1481.    fhandle = Fopen(fbuffer,0);
  1482.    if(fhandle <= 0)
  1483.    {
  1484.     free(clippage);
  1485.     free(docbuf);
  1486.     alert_cntre(ALERT16);
  1487.     return(1);
  1488.    }
  1489.    bytes_in = Fread(fhandle,thedta.fsize,docbuf);
  1490.    if(bytes_in < thedta.fsize)
  1491.    {
  1492.     free(clippage);
  1493.     free(docbuf);
  1494.     alert_cntre(ALERT17);
  1495.         Fclose(fhandle);
  1496.     return(1);
  1497.    }
  1498.    Fclose(fhandle);
  1499.    if(!read_regions())
  1500.    {
  1501.     clean_regions();
  1502.     alert_cntre();
  1503.     free(rtable);
  1504.     free(docbuf);
  1505.     free(clippage);
  1506.     return(1);
  1507.    }
  1508.    for(i = 0;i < gl_rcount;i++)
  1509.    {
  1510.         rptr = (REGION *)rtable[i];
  1511.         rptr->plink = getrptr((int)rptr->plink);
  1512.    }
  1513.    clippage->regptr = (REGION *)rtable[0];
  1514.  
  1515.    free(rtable);
  1516.    free(docbuf);
  1517.    return(0);            /* normal return   */
  1518. }
  1519.  
  1520.  
  1521.  
  1522.  
  1523.  
  1524.  
  1525. /**********************************************************************/
  1526. /* Function: extender()                              */
  1527. /* Description: handle file name extenders                  */
  1528. /**********************************************************************/
  1529. extender(fname,ext)
  1530. char *fname;
  1531. register char *ext;
  1532. {
  1533.      register char *s;
  1534.      
  1535.      s = fname;
  1536.      while((*s != '.') && (*s != '\0'))
  1537.                 *s++;
  1538.  
  1539.      if(*s == '\0')
  1540.       strcat(fname,ext);
  1541.      else
  1542.      {    
  1543.        *s++;
  1544.        *ext++;
  1545.        if(*s == '\0')
  1546.       strcat(fname,ext);
  1547.      }
  1548. }
  1549.  
  1550.  
  1551.  
  1552.  
  1553. load_path()
  1554. {
  1555.    long bufsize;
  1556.    
  1557.    Fsetdta(&thedta.res[0]);
  1558.    if(Fsfirst("DESK2.PTH",0) <= -1)
  1559.    {
  1560.     return(0);            /* path file not found */
  1561.    }                    /* so use the defaults */
  1562.    bufsize = thedta.fsize;
  1563.    if(bufpath = lcalloc(1L,bufsize))
  1564.    {
  1565.       fhandle = Fopen("DESK2.PTH",0);
  1566.       bytes_in = Fread(fhandle,thedta.fsize,bufpath);
  1567.       Fclose(fhandle);
  1568.       return(1);
  1569.    }
  1570. }
  1571.  
  1572.  
  1573.  
  1574. write_paths(dpath1,dpath2,dpath3,dpath4)
  1575. char *dpath1;
  1576. char *dpath2;
  1577. char *dpath3;
  1578. char *dpath4;
  1579. {
  1580.         pbufindex = 0;
  1581.     add_slash(dpath1);
  1582.     bputstr(dpath1);
  1583.     bputcr();
  1584.     add_slash(dpath2);
  1585.     bputstr(dpath2);
  1586.     bputcr();
  1587.     add_slash(dpath3);
  1588.     bputstr(dpath3);
  1589.     bputcr();
  1590.     add_slash(dpath4);
  1591.     bputstr(dpath4);
  1592.     bputcr();
  1593.    
  1594.     if( (fhandle = Fcreate("DESK2.PTH",0)) > 0)
  1595.         {
  1596.        Fwrite(fhandle,200L,pbuff);
  1597.        Fclose(fhandle);
  1598.         }
  1599. }
  1600.  
  1601.  
  1602.  
  1603. store_paths(dpath1,dpath2,dpath3,dpath4)
  1604. char *dpath1;
  1605. char *dpath2;
  1606. char *dpath3;
  1607. char *dpath4;
  1608. {
  1609.         pbufindex = 0;
  1610.     bputstr(dpath1);
  1611.     bputcr();
  1612.     bputstr(dpath2);
  1613.     bputcr();
  1614.     bputstr(dpath3);
  1615.     bputcr();
  1616.     bputstr(dpath4);
  1617.     bputcr();
  1618. }
  1619.  
  1620.  
  1621. bputstr(str)
  1622. register char *str;
  1623. {
  1624.    while(*str)
  1625.       pbuff[pbufindex++] = *str++;
  1626. }
  1627.  
  1628.  
  1629. bputcr()
  1630. {
  1631.    pbuff[pbufindex++] = 0x0D;
  1632.    pbuff[pbufindex++] = 0x0A;
  1633. }
  1634.  
  1635. read_path(dpath1,dpath2,dpath3,dpath4)
  1636. char *dpath1;
  1637. char *dpath2;
  1638. char *dpath3;
  1639. char *dpath4;
  1640. {
  1641.    pbufindex = 0;
  1642.  
  1643.    Fsetdta(&thedta.res[0]);
  1644.    if(Fsfirst("DESK2.PTH",0) <= -1)
  1645.    {
  1646.     return(0);
  1647.    }
  1648.    fhandle = Fopen("DESK2.PTH",0);
  1649.    bytes_in = Fread(fhandle,thedta.fsize,pbuff);
  1650.    Fclose(fhandle);
  1651.  
  1652.    bgetstr(dpath1);
  1653.    bgetstr(dpath2);
  1654.    bgetstr(dpath3);
  1655.    bgetstr(dpath4);
  1656.    return(1);
  1657. }
  1658.  
  1659.  
  1660.  
  1661. bgetstr(dpath)
  1662. register char *dpath;
  1663. {
  1664.      while(pbuff[pbufindex] != 0x0D)
  1665.         *dpath++ = pbuff[pbufindex++];
  1666.      pbufindex++;            /* get rid of 0x0D */   
  1667.      pbufindex++;            /* get rid of 0x0A */   
  1668.      *dpath++ = 0x0;
  1669. }
  1670.  
  1671.  
  1672.  
  1673. restore_paths(dpath1,dpath2,dpath3,dpath4)
  1674. char *dpath1;
  1675. char *dpath2;
  1676. char *dpath3;
  1677. char *dpath4;
  1678. {
  1679.    pbufindex = 0;
  1680.    bgetstr(dpath1);
  1681.    bgetstr(dpath2);
  1682.    bgetstr(dpath3);
  1683.    bgetstr(dpath4);
  1684. }
  1685.  
  1686.  
  1687.  
  1688. remove_path(str)
  1689. char *str;
  1690. {
  1691.    char s[100];
  1692.    register int  i; 
  1693.  
  1694.    i = 0;
  1695.    strcpy(&s[0],str);
  1696.  
  1697.    while(s[i++]);
  1698.  
  1699.    while(s[i-1] != '\\' && i)
  1700.        i--;
  1701.    strcpy(str,&s[i]);
  1702. }
  1703.  
  1704.  
  1705.  
  1706. write_ptype()
  1707. {
  1708.     if(!dwrite(&pagetype,2))
  1709.             return(0);
  1710.     else return(1);
  1711. }
  1712.  
  1713.  
  1714.  
  1715. read_ptype()
  1716. {
  1717.    dread(&pagetype,2);            /* Don't forget landscape */
  1718.    if( (pagetype >= PA4) && (pagetype <= (PLEGAL + 4))) /* <- + 4 */
  1719.                 return;
  1720.    else
  1721.       pagetype = PLETTER;
  1722. }
  1723.  
  1724.  
  1725.  
  1726. write_tmplates()
  1727. {
  1728.   register unsigned int pcount,acount,rcount;
  1729.   unsigned long rtblsize;
  1730.   unsigned long atblsize;
  1731.   int lap;
  1732.   ARTICLE *aptr;
  1733.   REGION *rptr;
  1734.  
  1735.   for(lap = 0;lap <= 1;lap++)
  1736.   {
  1737.     if(lap)
  1738.     {
  1739.       pagehd = curpage = right_tmplate;
  1740.       curr_page = right_tmplate->pagenum;
  1741.       arthd = rtarthd;
  1742.     }
  1743.     else
  1744.     {
  1745.       pagehd = curpage = left_tmplate;
  1746.       curr_page = left_tmplate->pagenum;
  1747.       arthd = ltarthd;
  1748.     }
  1749.     
  1750.     pcount = 1;
  1751.     acount = rcount = 0;
  1752.     rptr = get_fregion(curr_page,&dummy,&dummy,&dummy,&dummy,&dummy);
  1753.     while(rptr)
  1754.     {
  1755.       rcount++;
  1756.       rptr = get_nregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  1757.     }
  1758.  
  1759.     rtblsize = 4L * ((long)rcount + 1L);
  1760.  
  1761.     rtable = (long *)lmalloc(rtblsize);
  1762.     if(!rtable)
  1763.     {
  1764.     alert_cntre(ALERT12);
  1765.     return;
  1766.     }
  1767.     rtbl_setup();
  1768.     aptr = getf_article();
  1769.     while(aptr)
  1770.     {
  1771.     acount++;
  1772.     aptr = getn_article();
  1773.     }
  1774.     atblsize = 4L * ((long)acount + 1L);
  1775.     atable = (long *)lmalloc(atblsize);
  1776.     if(!atable)
  1777.     {
  1778.     free(rtable);
  1779.     alert_cntre(ALERT12);
  1780.     return;
  1781.     }
  1782.     atbl_setup();
  1783.     if(write_pages(pcount)     &&
  1784.        write_articles(acount)  &&
  1785.        write_regions(rcount))
  1786.     ;
  1787.     else
  1788.     {    
  1789.     alert_cntre(ALERT20);
  1790.         free(atable);
  1791.         free(rtable);
  1792.     return;
  1793.     }
  1794.     free(atable);
  1795.     free(rtable);
  1796.   }
  1797.   if(!ddump())
  1798.     alert_cntre(ALERT20);
  1799.   return;
  1800. }
  1801.  
  1802.  
  1803. read_tmplates()
  1804. {
  1805.   int i;
  1806.  
  1807.   for(i=0;i<=1;i++)
  1808.   {
  1809.     pagehd = curpage = ((i)?(right_tmplate):(left_tmplate)); 
  1810.     arthd = ((i)?(rtarthd):(ltarthd));
  1811.     tread_pages();
  1812.     read_articles();
  1813.     read_regions();
  1814.     fixup_rptrs();
  1815.     load_arts();
  1816.     recalc_txtptrs();  
  1817.     if(rtable)
  1818.          free(rtable);
  1819.     if(i)
  1820.       rtarthd = arthd;
  1821.     else
  1822.     ltarthd = arthd;
  1823.   }
  1824.   return(1);
  1825. }
  1826.  
  1827.  
  1828.  
  1829. tread_pages()
  1830. {
  1831.   int pcount;
  1832.   int pagenum;
  1833.   unsigned int rindex;
  1834.   long temp;
  1835.   register PAGE *prevpage;
  1836.  
  1837.   prevpage = pagehd;  
  1838.   dread(&pcount,2);
  1839.   dread(&pagenum,2);
  1840.   prevpage->pagenum = pagenum;
  1841.   dread(&rindex,2);
  1842.   temp = ((long)rindex & 0xffff);
  1843.   prevpage->regptr = (REGION *)temp;
  1844.   prevpage->nextpage = 0L;
  1845. }
  1846.  
  1847.  
  1848.  
  1849.  
  1850. load_tmplate()
  1851. {
  1852.  
  1853.    long bufsize;
  1854.    int dummy;
  1855.  
  1856.    strcpy(pathbuf,dpath2);
  1857.    strcat(pathbuf,"*.BPL");
  1858.    if(!get_fs(fbuffer,&dummy))
  1859.    {
  1860.     return;
  1861.    }
  1862.    extender(fbuffer,".BPL");
  1863.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  1864.    if(Fsfirst(fbuffer,0) <= -1)
  1865.    {
  1866.     alert_cntre(ALERT8);
  1867.     return;
  1868.    }
  1869.    rtmplate_flag = tmplate_flag;
  1870.    rtemp_page = curr_page;
  1871.    rpagehd    = pagehd;
  1872.    rcurpage   = curpage;
  1873.    rarthd     = arthd;
  1874.  
  1875.    bufsize = thedta.fsize;
  1876.  
  1877.    if(!bufsize)
  1878.    {
  1879.     alert_cntre(ALERT39);
  1880.     return;
  1881.    }
  1882.  
  1883.    docbuf = (char *)lcalloc(1L,bufsize);
  1884.    if(!docbuf)
  1885.    {
  1886.     alert_cntre(ALERT12);
  1887.     return;
  1888.    }
  1889.    docptr = docbuf;
  1890.    if((fhandle = Fopen(fbuffer,0)) <= 0)
  1891.    {
  1892.     alert_cntre(ALERT16);
  1893.     free(docbuf);
  1894.     return;
  1895.    }
  1896.    bytes_in = Fread(fhandle,thedta.fsize,docbuf);
  1897.    if(bytes_in < thedta.fsize)
  1898.    {
  1899.     alert_cntre(ALERT17);
  1900.     free(docbuf);
  1901.         Fclose(fhandle);
  1902.     return;
  1903.    }
  1904.    Fclose(fhandle);
  1905.    delete_tmplates();
  1906.    if(!read_tmplates())
  1907.    {
  1908.     free(docbuf);
  1909.         tmplate_flag = rtmplate_flag;
  1910.         curr_page    = rtemp_page;
  1911.         pagehd       = rpagehd;
  1912.         curpage      = rcurpage;
  1913.          arthd         = rarthd;
  1914.     return;
  1915.    }
  1916.    free(docbuf);
  1917.    strcpy(basefname," ");
  1918.    strcat(basefname,fname);
  1919.    strcat(basefname," ");
  1920.  
  1921.    tmplate_flag = rtmplate_flag;
  1922.  
  1923.    if(tmplate_flag)
  1924.    {
  1925.      pagehd = curpage = ((curr_page % 2) ? (right_tmplate):(left_tmplate));
  1926.      curr_page = pagehd->pagenum;
  1927.      arthd = ((curr_page % 2)?(rtarthd):(ltarthd));
  1928.      wind_set(prev_handle,WF_NAME,basefname,0,0);
  1929.    }
  1930.    else
  1931.    {
  1932.      curr_page    = rtemp_page;
  1933.      pagehd       = rpagehd;
  1934.      curpage      = rcurpage;
  1935.      arthd      = rarthd;
  1936.    }
  1937.    force_preview();
  1938. }
  1939.  
  1940.  
  1941.  
  1942.  
  1943.  
  1944.  
  1945. save_tmplate()
  1946. {
  1947.    int dummy;
  1948.  
  1949.    if(!right_tmplate->regptr && !left_tmplate->regptr)
  1950.                 return;
  1951.  
  1952.    strcpy(pathbuf,dpath2);
  1953.    strcat(pathbuf,"*.BPL");
  1954.    if(!get_fs(fbuffer,&dummy))
  1955.    {
  1956.        return;
  1957.    }
  1958.  
  1959.    push_tmplate();        /* Save global variables*/
  1960.  
  1961.  
  1962.    extender(fbuffer,".BPL");   
  1963.  
  1964.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  1965.    if(Fsfirst(fbuffer,0) == 0)            /* File Already Exists  */
  1966.    {
  1967.     if(alert_cntre(ALERT37) == 2)        /* Cancel Button pressed*/
  1968.     {
  1969.        pop_tmplate();    
  1970.        return;
  1971.     }
  1972.    }
  1973.  
  1974.    if((fhandle = Fcreate(fbuffer,0)) <=0)
  1975.    {
  1976.     alert_cntre(ALERT19);
  1977.     pop_tmplate();
  1978.     return;
  1979.    }
  1980.    docbuf = (char *)lmalloc(DOCSIZE);
  1981.    if(!docbuf)
  1982.    {
  1983.     alert_cntre(ALERT12);
  1984.     pop_tmplate();
  1985.     return;
  1986.    }
  1987.    docptr = docbuf;
  1988.    docend = docbuf + DOCSIZE - 1;
  1989.    write_tmplates();
  1990.    free(docbuf);
  1991.    Fclose(fhandle);
  1992.  
  1993.    pop_tmplate();        /* Restore global variables */
  1994.    strcpy(basefname," ");
  1995.    strcat(basefname,fname);
  1996.    extender(basefname,".BPL");
  1997.    strcat(basefname," ");
  1998.    if(tmplate_flag)
  1999.         wind_set(prev_handle,WF_NAME,basefname,0,0);
  2000. }
  2001.  
  2002.  
  2003.  
  2004.  
  2005. write_pnums()
  2006. {
  2007.     if(!dwrite(&pnum,sizeof(struct pnumber)))
  2008.                 return(0);
  2009.     else return(1);
  2010. }
  2011.  
  2012.  
  2013.  
  2014. read_pnums()
  2015. {
  2016.     dread(&pnum,sizeof(struct pnumber));   
  2017. }
  2018.  
  2019.  
  2020.  
  2021.  
  2022.  
  2023. write_defaults()
  2024. {
  2025.    int fd;
  2026.  
  2027.    if((fd = Fcreate("DESK2.DFT",0)) > 0)
  2028.    {
  2029.     Fwrite(fd,102L,pstorage);
  2030.     Fwrite(fd,(long)pstorage[50],pnumtext);
  2031.     Fclose(fd);
  2032.    }
  2033.  
  2034. }
  2035.  
  2036.  
  2037.  
  2038.  
  2039. read_defaults()
  2040. {
  2041.      int fd;
  2042.      int nbytes;
  2043.  
  2044.      Fsetdta(&thedta.res[0]);
  2045.      if(Fsfirst("DESK2.DFT",0) <= -1)
  2046.                  return(0);
  2047.      fd = Fopen("DESK2.DFT",0);
  2048.      nbytes = Fread(fd,102L,pstorage);
  2049.      nbytes = Fread(fd,(long)pstorage[50],pnumtext);
  2050.      Fclose(fd);
  2051.      return(1);
  2052. }
  2053.  
  2054.  
  2055.  
  2056.  
  2057.  
  2058.  
  2059. /* Save these variables for save_doc()    */
  2060. /* this was necessary if in tmplate mode*/
  2061. push_sdoc()
  2062. {
  2063.    rtmplate_flag = tmplate_flag;
  2064.    rtemp_page = curr_page;
  2065.    if(tmplate_flag)
  2066.    {
  2067.       rpagehd = pagehd;
  2068.       rcurpage = curpage;
  2069.       rarthd   = arthd;
  2070.  
  2071.       pagehd = tpagehd;
  2072.       curpage = tcurpage;
  2073.       arthd   = tarthd;
  2074.  
  2075.       tmplate_flag = FALSE;
  2076.    }
  2077.  
  2078. }
  2079.  
  2080.  
  2081.  
  2082.  
  2083.  
  2084. /* Restore original variables for save_doc()*/
  2085. pop_sdoc()
  2086. {
  2087.    tmplate_flag = rtmplate_flag;
  2088.    curr_page = rtemp_page;
  2089.    if(tmplate_flag)
  2090.    {
  2091.      pagehd = rpagehd;
  2092.      curpage = rcurpage;
  2093.      arthd   = rarthd;
  2094.    }
  2095.  
  2096. }
  2097.  
  2098.  
  2099.  
  2100. /* Save global variables for save tmplate */
  2101. /* related to if in tmplate mode       */
  2102. push_tmplate()
  2103. {
  2104.    rtmplate_flag = tmplate_flag;
  2105.    rtemp_page = curr_page;
  2106.    rpagehd    = pagehd;
  2107.    rcurpage   = curpage;
  2108.    rarthd     = arthd;
  2109. }
  2110.  
  2111.  
  2112.  
  2113. /* Restore global variables in save_tmplate*/
  2114. pop_tmplate()
  2115. {
  2116.    arthd        = rarthd;
  2117.    tmplate_flag = rtmplate_flag;
  2118.    curr_page    = rtemp_page;
  2119.    pagehd       = rpagehd;
  2120.    curpage      = rcurpage;
  2121. }
  2122.  
  2123.  
  2124.  
  2125.  
  2126. add_slash(path)
  2127. char *path;
  2128. {
  2129.    int i;
  2130.  
  2131.    i = strlen(path);   
  2132.    if(path[i-1] != '\\')
  2133.     strcat(path,"\\");
  2134. }
  2135.  
  2136.  
  2137.  
  2138. load_tags()
  2139. {
  2140.   int dummy;
  2141.   long bufsize;
  2142.  
  2143.   strcpy(pathbuf,dpath2);
  2144.   strcat(pathbuf,"*.TAG");
  2145.   if(!get_fs(fbuffer,&dummy))
  2146.   {
  2147.     return;
  2148.   }
  2149.  
  2150.   extender(fbuffer,".TAG");
  2151.   Fsetdta(&thedta.res[0]);
  2152.   if(Fsfirst(fbuffer,0) <= -1)
  2153.   {
  2154.      alert_cntre(ALERT8);
  2155.      return;
  2156.   }
  2157.  
  2158.   
  2159.   bufsize = thedta.fsize;
  2160.   if(!bufsize)
  2161.   {
  2162.     alert_cntre(ALERT39);
  2163.     return;
  2164.   }
  2165.  
  2166.   docbuf  = (char *)lcalloc(1L,bufsize);
  2167.   if(!docbuf)
  2168.   {
  2169.     alert_cntre(ALERT12);
  2170.     return;
  2171.   }
  2172.  
  2173.   docptr = docbuf;
  2174.   if((fhandle = Fopen(fbuffer,0)) <= 0)
  2175.   {
  2176.      alert_cntre(ALERT16);
  2177.      free(docbuf);
  2178.      return;
  2179.   }
  2180.  
  2181.   bytes_in = Fread(fhandle,thedta.fsize,docbuf);
  2182.   if(bytes_in < thedta.fsize)
  2183.   {
  2184.      alert_cntre(ALERT17);
  2185.      free(docbuf);
  2186.      Fclose(fbuffer);     
  2187.      return;
  2188.   }
  2189.   Fclose(fbuffer);
  2190.  
  2191.   clear_tags();
  2192.   read_tags();
  2193.   free(docbuf);
  2194. }
  2195.  
  2196.  
  2197.  
  2198.  
  2199. save_tags()
  2200. {
  2201.    int dummy;
  2202.  
  2203.    strcpy(pathbuf,dpath2);
  2204.    strcat(pathbuf,"*.TAG");
  2205.    if(!get_fs(fbuffer,&dummy))
  2206.    {
  2207.     return;
  2208.    }
  2209.  
  2210.    extender(fbuffer,".TAG");
  2211.  
  2212.    Fsetdta(&thedta.res[0]);
  2213.    if(Fsfirst(fbuffer,0) == 0)
  2214.    {
  2215.     if(alert_cntre(ALERT37) == 2)    /* Cancel Button */
  2216.     {
  2217.          return;
  2218.     }
  2219.    }
  2220.  
  2221.    if((fhandle = Fcreate(fbuffer,0)) <= 0)
  2222.    {
  2223.     alert_cntre(ALERT19);
  2224.     return;
  2225.    }
  2226.  
  2227.    docbuf = (char *)lmalloc(DOCSIZE);
  2228.    if(!docbuf)
  2229.    {
  2230.     alert_cntre(ALERT12);
  2231.     return;
  2232.    }
  2233.    docptr = docbuf;
  2234.    docend = docbuf + DOCSIZE - 1;
  2235.    
  2236.    if(write_tags())
  2237.        ddump();    /* let AES handle error message */
  2238.    free(docbuf);
  2239.    if(Fclose(fhandle))
  2240.      alert_cntre(ALERT18);
  2241. }
  2242.  
  2243.  
  2244.  
  2245.  
  2246.  
  2247. read_GOG()
  2248. {
  2249.    pbufindex = 0;
  2250.  
  2251.    Fsetdta(&thedta.res[0]);
  2252.    if(Fsfirst("GOG.DFT",0) <= -1)
  2253.    {
  2254.     return(0);
  2255.    }
  2256.    fhandle = Fopen("GOG.DFT",0);
  2257.    bytes_in = Fread(fhandle,thedta.fsize,GOGbuff);
  2258.    Fclose(fhandle);
  2259.  
  2260.    GOGgetstr(setp.ftdrs);
  2261.    GOGgetstr(setp.edict);
  2262.    GOGgetstr(setp.kblyt);
  2263.    return(1);
  2264. }
  2265.  
  2266.  
  2267.  
  2268.  
  2269. GOGgetstr(dpath)
  2270. register char *dpath;
  2271. {
  2272.      while(GOGbuff[GOGindex] != 0x0D)
  2273.         *dpath++ = GOGbuff[GOGindex++];
  2274.      GOGindex++;            /* get rid of 0x0D */   
  2275.      GOGindex++;            /* get rid of 0x0A */   
  2276.      *dpath++ = 0x0;
  2277. }
  2278.  
  2279.  
  2280.  
  2281.  
  2282. write_GOG()
  2283. {
  2284.         GOGindex = 0;
  2285.     GOGputstr(setp.ftdrs);
  2286.     GOGputcr();
  2287.     GOGputstr(setp.edict);
  2288.     GOGputcr();
  2289.     GOGputstr(setp.kblyt);
  2290.     GOGputcr();
  2291.    
  2292.     if( (fhandle = Fcreate("GOG.DFT",0)) > 0)
  2293.         {
  2294.        Fwrite(fhandle,50L,GOGbuff);
  2295.        Fclose(fhandle);
  2296.         }
  2297. }
  2298.  
  2299.  
  2300.  
  2301. GOGputstr(str)
  2302. register char *str;
  2303. {
  2304.    while(*str)
  2305.       GOGbuff[GOGindex++] = *str++;
  2306. }
  2307.  
  2308.  
  2309. GOGputcr()
  2310. {
  2311.    GOGbuff[GOGindex++] = 0x0D;
  2312.    GOGbuff[GOGindex++] = 0x0A;
  2313. }
  2314.